const app = getApp()

Page({
  data: {
    isRecording: false,
    recordingTime: '00:00',
    startTime: null,
    timer: null,
    currentRecord: null,
    lastPoopTime: null,
    timeSinceLastPoop: '暂无记录',
    showActionSheet: false,
    actionSheetTitle: '描述您的感受',
    actionSheetItems: [],
    // 超时和提醒相关
    timeoutMinutes: 15
  },

  onLoad() {
    try {
      // 加载用户超时设置
      const timeoutMinutes = wx.getStorageSync('timeoutMinutes') || 15
      this.setData({ timeoutMinutes })
      
      // 检查是否有正在进行的记录
      const timerState = wx.getStorageSync('poopTimerState')
      
      if (timerState && timerState.isRecording) {
        this.setData({
          isRecording: true,
          startTime: new Date(timerState.startTime),
          currentRecord: timerState.currentRecord
        })
        this.startTimer()
      }
      
      // 计算距离上次便便的时间
      this.calculateTimeSinceLastPoop()
      
      // 每分钟更新一次距离上次便便的时间
      this.lastPoopTimer = setInterval(() => {
        this.calculateTimeSinceLastPoop()
      }, 60000) // 每分钟更新一次
      
    } catch (error) {
      // 静默处理错误
    }
  },

  onShow() {
    // 重新加载超时设置（用户可能在设置页面修改了）
    const timeoutMinutes = wx.getStorageSync('timeoutMinutes') || 15
    this.setData({ timeoutMinutes })
    
    // 页面显示时，重新计算距离上次便便的时间
    this.calculateTimeSinceLastPoop()
    
    // 如果正在记录，检查是否已经超时
    if (this.data.isRecording && this.data.startTime) {
      const now = new Date()
      const elapsedMinutes = Math.floor((now - this.data.startTime) / 60000)
      
      if (elapsedMinutes >= timeoutMinutes) {
        // 已经超时，直接保存超时记录
        this.saveTimeoutRecord()
        return
      }
      
      // 没有超时，继续计时
      this.startTimer()
    }
  },

  onHide() {
    // 页面隐藏时，如果正在记录，保存计时器状态
    if (this.data.isRecording) {
      this.saveTimerState()
    }
  },

  onUnload() {
    // 页面卸载时，如果正在记录，保存计时器状态并清除计时器
    if (this.data.isRecording) {
      this.saveTimerState()
      this.clearTimer()
    }
    
    // 清除上次便便时间的定时器
    if (this.lastPoopTimer) {
      clearInterval(this.lastPoopTimer)
    }
    
    
  },

  // 计算距离上次便便的时间
  calculateTimeSinceLastPoop() {
    const records = wx.getStorageSync('poopRecords') || []
    
    if (records.length === 0) {
      this.setData({
        lastPoopTime: null,
        timeSinceLastPoop: '暂无记录'
      })
      return
    }
    
    // 按时间倒序排序，获取最近一次记录
    const sortedRecords = records.sort((a, b) => {
      // 安全检查：确保记录有必要的字段
      if (!a || !a.date || !a.time) {
        return 1 // 将无效记录排到后面
      }
      if (!b || !b.date || !b.time) {
        return -1 // 将无效记录排到后面
      }
      
      // 处理不同的时间格式
      let dateTimeA, dateTimeB
      
      // 安全处理time字段
      const timeA = (typeof a.time === 'string' && a.time.includes(':') && a.time.split(':').length === 3) 
        ? a.time 
        : (a.time || '00:00') + ':00'
      const timeB = (typeof b.time === 'string' && b.time.includes(':') && b.time.split(':').length === 3) 
        ? b.time 
        : (b.time || '00:00') + ':00'
      
      dateTimeA = new Date(a.date + 'T' + timeA)
      dateTimeB = new Date(b.date + 'T' + timeB)
      
      // 如果日期解析失败，尝试其他格式
      if (isNaN(dateTimeA.getTime())) {
        dateTimeA = new Date(a.date + ' ' + (a.time || '00:00'))
      }
      if (isNaN(dateTimeB.getTime())) {
        dateTimeB = new Date(b.date + ' ' + (b.time || '00:00'))
      }
      
      return dateTimeB - dateTimeA
    })
    
    const lastRecord = sortedRecords[0]
    
    // 安全检查最后记录
    if (!lastRecord || !lastRecord.date || !lastRecord.time) {
      this.setData({
        lastPoopTime: null,
        timeSinceLastPoop: '记录数据异常'
      })
      return
    }
    
    // 构造最后一次记录的时间
    let lastTime
    const timeStr = (typeof lastRecord.time === 'string' && lastRecord.time.includes(':') && lastRecord.time.split(':').length === 3) 
      ? lastRecord.time 
      : (lastRecord.time || '00:00') + ':00'
    
    lastTime = new Date(lastRecord.date + 'T' + timeStr)
    
    // 如果日期解析失败，尝试其他格式
    if (isNaN(lastTime.getTime())) {
      lastTime = new Date(lastRecord.date + ' ' + (lastRecord.time || '00:00'))
    }
    
    // 如果还是解析失败，使用当前时间作为fallback
    if (isNaN(lastTime.getTime())) {
      this.setData({
        lastPoopTime: null,
        timeSinceLastPoop: '时间解析错误'
      })
      return
    }
    
    const now = new Date()
    const diffMs = now - lastTime
    
    // 如果时间差为负数，说明记录时间在未来，这是不正常的
    if (diffMs < 0) {
      this.setData({
        lastPoopTime: lastTime,
        timeSinceLastPoop: '时间异常'
      })
      return
    }
    
    // 计算时间差
    const diffMins = Math.floor(diffMs / 60000)
    const diffHours = Math.floor(diffMins / 60)
    const diffDays = Math.floor(diffHours / 24)
    
    let timeSinceLastPoop = ''
    if (diffDays > 0) {
      timeSinceLastPoop = `${diffDays}天${diffHours % 24}小时`
    } else if (diffHours > 0) {
      timeSinceLastPoop = `${diffHours}小时${diffMins % 60}分钟`
    } else if (diffMins > 0) {
      timeSinceLastPoop = `${diffMins}分钟`
    } else {
      timeSinceLastPoop = '刚刚'
    }
    
    this.setData({
      lastPoopTime: lastTime,
      timeSinceLastPoop: timeSinceLastPoop
    })
  },



  // 开始/结束便便记录
  togglePoopRecording() {
    try {
      if (this.data.isRecording) {
        // 结束记录
        this.endPoopRecording()
      } else {
        // 开始记录
        this.startPoopRecording()
      }
    } catch (error) {
      const customToast = this.selectComponent('#customToast')
      if (customToast) {
        customToast.showToast('操作失败')
      }
    }
  },

  // 开始便便记录
  startPoopRecording() {
    try {
      const now = new Date()
      
      this.setData({
        isRecording: true,
        startTime: now,
        recordingTime: '00:00',
        currentRecord: {
          id: Date.now().toString(),
          date: this.formatDate(now),
          startTime: this.formatTime(now),
          duration: 0,
          durationSeconds: 0
        }
      })
      
      // 启动计时器
      this.startTimer()
    } catch (error) {
      const customToast = this.selectComponent('#customToast')
      if (customToast) {
        customToast.showToast('启动记录失败')
      }
    }
  },

  // 结束便便记录
  endPoopRecording() {
    // 清除计时器
    this.clearTimer()
    
    const endTime = new Date()
    const durationMs = endTime - this.data.startTime
    const durationMinutes = Math.floor(durationMs / 60000)
    const durationSeconds = Math.floor((durationMs % 60000) / 1000)
    
    // 更新当前记录
    const currentRecord = {
      ...this.data.currentRecord,
      endTime: this.formatTime(endTime),
      time: this.data.currentRecord.startTime,
      duration: durationMinutes,
      durationSeconds: durationSeconds,
      durationText: `${durationMinutes}分${durationSeconds}秒`
    }
    
    this.setData({
      isRecording: false,
      currentRecord
    })
    
    // 弹出便便类型选择
    this.showPoopTypeSelector()
  },

  // 显示便便类型选择器
  showPoopTypeSelector() {
    const poopTypes = getApp().globalData.poopTypes
    const items = poopTypes.map(type => ({
      emoji: type.emoji || '💩',
      name: type.name
    }))
    
    this.setData({
      showActionSheet: true,
      actionSheetItems: items
    })
  },

  // 处理 ActionSheet 选择事件
  handleActionSheetSelect(e) {
    const { index } = e.detail
    const poopTypes = getApp().globalData.poopTypes
    const typeId = poopTypes[index].id
    const typeName = poopTypes[index].name
    
    // 更新当前记录的类型
    this.setData({
      'currentRecord.typeId': typeId,
      'currentRecord.typeName': typeName,
      showActionSheet: false
    })
    
    if (typeId === 2) { // 异常情况下才显示备注输入框
      // 使用自定义模态框组件
      const modal = this.selectComponent('#poopNoteModal')
      modal.setData({
        show: true,
        title: '添加备注',
        placeholder: '例如：今天肚子有点不舒服...',
        inputValue: ''
      })
    } else {
      // 正常情况直接保存
      this.savePoopRecord('')
    }
  },

  // 处理 ActionSheet 关闭事件
  handleActionSheetClose() {
    this.setData({
      showActionSheet: false
    })
  },

  // 处理模态框确认事件
  handleModalConfirm(e) {
    this.savePoopRecord(e.detail)
  },

  // 处理模态框取消事件
  handleModalClose() {
    this.savePoopRecord('')
  },

  // 保存便便记录
  savePoopRecord(note) {
    const record = {
      ...this.data.currentRecord,
      note,
      duration: this.data.currentRecord.duration || 0,
      durationSeconds: this.data.currentRecord.durationSeconds || 0,
      durationText: this.formatDuration(
        this.data.currentRecord.duration || 0,
        this.data.currentRecord.durationSeconds || 0
      )
    }
    
    // 保存到本地存储
    const records = wx.getStorageSync('poopRecords') || []
    records.push(record)
    wx.setStorageSync('poopRecords', records)
    
    // 重置记录状态
    this.setData({
      isRecording: false,
      recordingTime: '00:00',
      startTime: null,
      currentRecord: {}
    })
    
    // 清除计时器
    this.clearTimer()
    
    // 使用自定义Toast提示成功
    const customToast = this.selectComponent('#customToast')
    customToast.showToast('记录成功啦！')
    
    // 添加震动反馈
    wx.vibrateShort({
      type: 'medium'
    })
  },

  // 格式化时长显示
  formatDuration(minutes, seconds) {
    return `${minutes}分${seconds}秒`
  },

  // 启动计时器
  startTimer() {
    try {
      // 检查是否有保存的计时状态
      const timerState = wx.getStorageSync('poopTimerState')
      
      if (timerState && timerState.isRecording) {
        // 恢复计时状态
        this.setData({
          startTime: new Date(timerState.startTime),
          currentRecord: timerState.currentRecord
        })
      }
      
      // 启动计时器
      this.data.timer = setInterval(() => {
        try {
          const now = new Date()
          const diff = now - this.data.startTime
          const minutes = Math.floor(diff / 60000)
          const seconds = Math.floor((diff % 60000) / 1000)
          
          this.setData({
            recordingTime: `${minutes.toString().padStart(2, '0')}:${seconds.toString().padStart(2, '0')}`,
            'currentRecord.duration': minutes,
            'currentRecord.durationSeconds': seconds
          })
          
          // 检查超时（只有在记录状态时才检查）
          if (this.data.isRecording && minutes >= this.data.timeoutMinutes) {
            this.autoEndRecording()
          }
          
        } catch (error) {
          // 静默处理计时器错误
        }
      }, 1000)
      
    } catch (error) {
      // 静默处理启动计时器错误
    }
   },
 
   // 清除计时器
  clearTimer() {
    if (this.data.timer) {
      clearInterval(this.data.timer)
      this.setData({ timer: null })
    }
    
    // 清除保存的计时状态
    wx.removeStorageSync('poopTimerState')
  },

  // 保存计时器状态
  saveTimerState() {
    wx.setStorageSync('poopTimerState', {
      isRecording: this.data.isRecording,
      startTime: this.data.startTime,
      currentRecord: this.data.currentRecord
    })
  },

  // 格式化日期：YYYY-MM-DD
  formatDate(date) {
    const year = date.getFullYear()
    const month = String(date.getMonth() + 1).padStart(2, '0')
    const day = String(date.getDate()).padStart(2, '0')
    return `${year}-${month}-${day}`
  },

  // 格式化时间：HH:MM:SS
  formatTime(date) {
    const hours = String(date.getHours()).padStart(2, '0')
    const minutes = String(date.getMinutes()).padStart(2, '0')
    const seconds = String(date.getSeconds()).padStart(2, '0')
    return `${hours}:${minutes}:${seconds}`
  },

  // 进入主页
  enterHome() {
    wx.switchTab({
      url: '/pages/start/start'
    })
  },

  // 自动结束记录
  autoEndRecording() {
    this.saveTimeoutRecord()
  },

  // 保存超时异常记录
  saveTimeoutRecord() {
    const endTime = new Date()
    
    // 使用设置的超时时间作为记录时长，而不是实际经过的时间
    const timeoutMinutes = this.data.timeoutMinutes
    const timeoutSeconds = 0 // 超时记录秒数设为0
    
    // 确保使用正确的开始时间作为记录时间
    const recordTime = this.data.currentRecord.startTime || this.formatTime(this.data.startTime)
    
    // 计算超时结束时间（开始时间 + 超时设置时间）
    const timeoutEndTime = new Date(this.data.startTime.getTime() + timeoutMinutes * 60000)
    
    // 创建超时异常记录
    const timeoutRecord = {
      ...this.data.currentRecord,
      endTime: this.formatTime(timeoutEndTime), // 使用计算出的超时结束时间
      time: recordTime, // 使用开始记录的时间
      duration: timeoutMinutes, // 使用设置的超时时间
      durationSeconds: timeoutSeconds,
      durationText: `${timeoutMinutes}分${timeoutSeconds}秒`,
      note: `异常：便便超时（超过${timeoutMinutes}分钟自动结束）`,
      type: '异常',
      typeId: 2,
      typeName: '异常',
      autoEnded: true,
      isTimeout: true // 标记为超时记录
    }
    
    // 保存到本地存储
    const records = wx.getStorageSync('poopRecords') || []
    records.push(timeoutRecord)
    wx.setStorageSync('poopRecords', records)
    
    // 重置记录状态
    this.setData({
      isRecording: false,
      recordingTime: '00:00',
      startTime: null,
      currentRecord: {}
    })
    
    // 清除计时器
    this.clearTimer()
    
    // 使用自定义Toast提示
    const customToast = this.selectComponent('#customToast')
    if (customToast) {
      customToast.showToast(`已自动记录为异常（超时${timeoutMinutes}分钟）`)
    }
    
    // 添加震动反馈
    wx.vibrateShort({
      type: 'medium'
    })
    
    // 重新计算距离上次便便的时间
    this.calculateTimeSinceLastPoop()
  },













  /**
   * 用户点击右上角分享
   */
  onShareAppMessage: function () {
    return {
      title: '记录美好生活的每一刻～',
      path: '/pages/start/start',
      imageUrl: 'https://gitee.com/teajoy/image/raw/master/images/share-cover.png'
    }
  },

  // 防止iOS系统的意外滚动
  preventTouchMove: function(e) {
    // 阻止默认的触摸移动行为，防止iOS系统的滚动
    e.preventDefault();
    return false;
  }
})